package com.hbnu.system.service.impl;

import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.hbnu.system.mapper.AchievementTypeMapper;
import com.hbnu.system.model.entity.AchievementType;
import com.hbnu.system.model.vo.ChildrenNameId;
import com.hbnu.system.model.vo.NameId;
import com.hbnu.system.service.AchievementTypeService;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@Service("achievementTypeService")
public class AchievementTypeServiceImpl extends ServiceImpl<AchievementTypeMapper, AchievementType> implements AchievementTypeService {

    @Override
    public List<NameId> getCascadingData() {
        List<AchievementType> achievementTypeList = baseMapper.selectList(Wrappers.lambdaQuery(AchievementType.class));

        // 1. 一级类型: Type1ID -> 名称 (Type1ID唯一)
        Map<Integer, String> type1Map = new HashMap<>();

        // 2. 二级类型: 用"Type1ID-Type2ID"作为唯一key（解决Type2ID重复问题）
        // key: "type1Id-type2Id"，value: 二级类型名称
        Map<String, String> type2Map = new HashMap<>();
        // key: "type1Id-type2Id"，value: 对应的一级Type1ID
        Map<String, Integer> type2ToType1 = new HashMap<>();
        // key: "type1Id-type2Id"，value: 二级Type2ID（用于构建节点value）
        Map<String, Integer> type2IdMap = new HashMap<>();

        // 3. 三级类型: 用记录主键ID作为唯一标识，关联二级的组合key
        Map<Integer, String> type3Map = new HashMap<>(); // key: 记录主键ID
        Map<Integer, String> type3ToType2 = new HashMap<>(); // key: 记录主键ID, value: 二级组合key("type1Id-type2Id")

        for (AchievementType at : achievementTypeList) {
            // 收集一级类型
            if (at.getType1Id() != null && at.getType1Id() > 0 && at.getAchievementType1() != null) {
                type1Map.putIfAbsent(at.getType1Id(), at.getAchievementType1());
            }

            // 收集二级类型（用"type1Id-type2Id"作为唯一key）
            if (at.getType1Id() != null && at.getType1Id() > 0 // 关联的一级Type1ID有效
                    && at.getType2Id() != null && at.getType2Id() > 0 // 二级Type2ID有效
                    && at.getAchievementType2() != null && !at.getAchievementType2().trim().isEmpty()
                    && !"无".equals(at.getAchievementType2().trim()) // 二级类型不是"无"
                    && at.getConnectionId1() != null && at.getConnectionId1().equals(at.getType1Id())) { // ConnectionID1必须等于所属一级Type1ID

                String type2Key = at.getType1Id() + "-" + at.getType2Id(); // 组合唯一key
                type2Map.putIfAbsent(type2Key, at.getAchievementType2());
                type2ToType1.putIfAbsent(type2Key, at.getType1Id()); // 关联到一级Type1ID
                type2IdMap.putIfAbsent(type2Key, at.getType2Id()); // 记录二级Type2ID
            }

            // 收集三级类型
            if (at.getAchievementType3() != null && !at.getAchievementType3().trim().isEmpty()
                    && !"无".equals(at.getAchievementType3().trim()) // 三级类型不是"无"
                    && at.getType1Id() != null && at.getType1Id() > 0 // 所属一级有效
                    && at.getType2Id() != null && at.getType2Id() > 0 // 所属二级有效
                    && at.getConnectionId2() != null && at.getConnectionId2().equals(at.getType2Id())) { // ConnectionID2必须等于所属二级Type2ID

                int recordId = at.getId(); // 用主键作为三级唯一标识
                String type2Key = at.getType1Id() + "-" + at.getType2Id(); // 关联的二级组合key
                type3Map.putIfAbsent(recordId, at.getAchievementType3());
                type3ToType2.putIfAbsent(recordId, type2Key);
            }
        }

        // 构建三级 -> 二级的子节点映射（key: 二级组合key）
        Map<String, List<NameId>> type2Children = new HashMap<>();
        for (Map.Entry<Integer, String> type3Entry : type3Map.entrySet()) {
            Integer recordId = type3Entry.getKey();
            String type3Name = type3Entry.getValue();
            String parentType2Key = type3ToType2.get(recordId);

            if (parentType2Key != null && type2Map.containsKey(parentType2Key)) {
                type2Children.computeIfAbsent(parentType2Key, k -> new ArrayList<>())
                        .add(new NameId(type3Name, recordId));
            }
        }

        // 构建二级 -> 一级的子节点映射（key: 一级Type1ID）
        Map<Integer, List<NameId>> type1Children = new HashMap<>();
        for (Map.Entry<String, String> type2Entry : type2Map.entrySet()) {
            String type2Key = type2Entry.getKey(); // 二级组合key
            String type2Name = type2Entry.getValue();
            Integer parentType1Id = type2ToType1.get(type2Key); // 关联的一级Type1ID
            Integer type2Id = type2IdMap.get(type2Key); // 二级Type2ID（作为节点value）

            if (parentType1Id != null && type1Map.containsKey(parentType1Id)) {
                // 三级子节点
                List<NameId> thirdLevel = type2Children.getOrDefault(type2Key, new ArrayList<>());

                // 构建二级节点（用Type2ID作为value，组合key仅用于内部关联）
                if (thirdLevel.isEmpty()) {
                    type1Children.computeIfAbsent(parentType1Id, k -> new ArrayList<>())
                            .add(new NameId(type2Name, type2Id));
                } else {
                    ChildrenNameId secondLevel = new ChildrenNameId(type2Name, type2Id);
                    secondLevel.setChildren(thirdLevel);
                    type1Children.computeIfAbsent(parentType1Id, k -> new ArrayList<>())
                            .add(secondLevel);
                }
            }
        }

        // 构建最终的一级节点列表
        List<NameId> result = new ArrayList<>();
        for (Map.Entry<Integer, String> type1Entry : type1Map.entrySet()) {
            Integer type1Id = type1Entry.getKey();
            String type1Name = type1Entry.getValue();
            // 该一级类型下的所有二级节点
            List<NameId> secondLevel = type1Children.getOrDefault(type1Id, new ArrayList<>());

            if (secondLevel.isEmpty()) {
                // 无二级节点，直接添加一级节点
                result.add(new NameId(type1Name, type1Id));
            } else {
                // 有二级节点，构建带children的一级节点
                ChildrenNameId firstLevel = new ChildrenNameId(type1Name, type1Id);
                firstLevel.setChildren(secondLevel);
                result.add(firstLevel);
            }
        }

        return result;
    }
}